SherbyNet - /page/wikibook/entry.mu

Micron Document

Elixir (programming language)

16.4 KB · ⇊ 10 parts · ⤓ Micron 16.4 KB · ⤓ HTML 61.0 KB

──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

top

Elixir is a functional, concurrent, high-level general-purpose programming language that runs on the BEAM virtual machine, which is also used to implement the Erlang programming language.cite-ref-0-3-0[3] Elixir builds on top of Erlang and shares the same abstractions for building distributed, fault-tolerant applications. Elixir also provides tooling and an extensible design. The latter is supported by compile-time metaprogramming with macros and polymorphism via protocols.cite-ref-4[4]

The community organizes yearly events in the United States,cite-ref-5[5] Europe,cite-ref-6[6] and Japan,cite-ref-7[7] as well as minor local events and conferences.cite-ref-8[8]cite-ref-9[9]

Contents

• History

• Versioning

• Features

• Examples

• See also

• References

• Further reading

History

José Valim created the Elixir programming language as a research and development project at Plataformatec. His goals were to enable higher extensibility and productivity in the Erlang VM while maintaining compatibility with Erlang's ecosystem.cite-ref-10[10]cite-ref-11[11]

Elixir is aimed at large-scale sites and apps. It uses features of Ruby, Erlang, and Clojure to develop a high-concurrency and low-latency language. It was designed to handle large data volumes. Elixir is also used in telecommunications, e-commerce, and finance.cite-ref-12[12]

In 2021, the Numerical Elixir effort was announced with the goal of bringing machine learning, neural networks, GPU compilation, data processing, and computational notebooks to the Elixir ecosystem.cite-ref-13[13]

Versioning

Each of the minor versions supports a specific range of Erlang/OTP versions.cite-ref-14[14] The current stable release version is 1.18.4cite-ref-wikidata-38d73dbc67fe379aec44b4c951a0b1d72113a0cd-v20-1-1[1] .

Features

• Compiles to bytecode for the BEAM virtual machine of Erlang.cite-ref-elixirhome-15-0[15] Full interoperability with Erlang code, without runtime impact.

• Scalability and fault-tolerance, thanks to Erlang's lightweight concurrency mechanismscite-ref-elixirhome-15-1[15]

• Built-in tooling for managing dependencies, code compilation, running tests, formatting code, remote debugging and more.

• An interactive REPL inside running programs, including Phoenix web servers, with code reloading and access to internal state

• Everything is an expressioncite-ref-elixirhome-15-2[15]

• Pattern matchingcite-ref-elixirhome-15-3[15] to promote assertive codecite-ref-16[16]

• Type hints for static analysis tools

• Immutable data, with an emphasis, like other functional languages, on recursion and higher-order functions instead of side-effect-based looping

• Shared nothing concurrent programming via message passing (actor model)cite-ref-17[17]

• Lazy and async collections with streams

• Railway oriented programming via the with constructcite-ref-18[18]

• Hygienic metaprogramming by direct access to the abstract syntax tree (AST).cite-ref-elixirhome-15-4[15] Libraries often implement small domain-specific languages, such as for databases or testing.

• Code execution at compile time. The Elixir compiler also runs on the BEAM, so modules that are being compiled can immediately run code which has already been compiled.

• Polymorphism via a mechanism called protocols. Dynamic dispatch, as in Clojure, however, without multiple dispatch because Elixir protocols dispatch on a single type.

• Support for documentation via Python-like docstrings in the Markdown formatting languagecite-ref-elixirhome-15-5[15]

• Unicode support and UTF-8 strings

Examples

The following examples can be run in an iex shell or saved in a file and run from the command line by typing elixir <filename>.

Classic Hello world example:

iex> IO.puts("Hello World!")

Hello World!

Pipe operator:

iex> "Elixir" |> String.graphemes() |> Enum.frequencies()

%{"E" => 1, "i" => 2, "l" => 1, "r" => 1, "x" => 1}

iex> %{values: 1..5} |> Map.get(:values) |> Enum.map(& &1 * 2)

[2, 4, 6, 8, 10]

iex> %{values: 1..5} |> Map.get(:values) |> Enum.map(& &1 * 2) |> Enum.sum()

Pattern matching (a.k.a. destructuring):

iex> %{left: x} = %{left: 5, right: 8}

iex> x

iex> {:ok, [_ | rest]} = {:ok, [1, 2, 3]}

iex> rest

[2, 3]

Pattern matching with multiple clauses:

iex> case File.read("path/to/file") do

iex> {:ok, contents} -> IO.puts("found file: #{contents}")

iex> {:error, reason} -> IO.puts("missing file: #{reason}")

iex> end

List comprehension:

iex> for n <- 1..5, rem(n, 2) == 1, do: n*n

[1, 9, 25]

Asynchronously reading files with streams:

1..5

|> Task.async_stream(&File.read!("#{&1}.txt"))

|> Stream.filter(fn {:ok, contents} -> String.trim(contents) != "" end)

|> Enum.join("\n")

Multiple function bodies with guards:

def fib(n) when n in [0, 1], do: n

def fib(n), do: fib(n-2) + fib(n-1)

Relational databases with the Ecto library:

schema "weather" do

field :city # Defaults to type :string

field :temp_lo, :integer

field :temp_hi, :integer

field :prcp, :float, default: 0.0

end

Weather |> where(city: "Kraków") |> order_by(:temp_lo) |> limit(10) |> Repo.all

Sequentially spawning a thousand processes:

for num <- 1..1000, do: spawn fn -> IO.puts("#{num * 2}") end

Asynchronously performing a task:

task = Task.async fn -> perform_complex_action() end

other_time_consuming_action()

Task.await task